Software of the Month Club 1998 May/Software of the Month Club 1998 May.iso/pc/dos/child/poetry/main.c

C/C++ Source or Header | 1998-03-03 | 24KB | 994 lines

/************* Random poetry generator ***********************/
/**                                                         **/
/**                           poetry.c                      **/
/**                                                         **/
/** Copyright (C) Paul Gaze 1997                            **/
/**     Please, notify me, if you make any                  **/
/**     changes to this file.                               **/
/*************************************************************/
#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
#include    <time.h>

#define    DEBUG_MESSAGES    0

//**************************************
//    Structures
//**************************************
typedef struct{
    char    *String;
    int        Subject,Object;
}VERB;

#define    MAX_LINE_LENGTH    256

#define    GENDA_HE    0
#define    GENDA_SHE    1
#define    GENDA_IT    2
#define    GENDA_THEY    3
#define    GENDA_I        4
#define    GENDA_WE    5

typedef struct{
    void    *Next;
    char    *String;
}TYPE_DATA;

typedef struct{
    char    *String;
    int        Genda;
    int        NTypes;
    int        *Types;
}NOUN;

typedef struct{
    int        NQuality;
    NOUN    *Quality;
    char    *String;
}TYPE;

typedef struct{
    int        NVerb;
    VERB    *Verb;
    int        NNoun;
    NOUN    *Noun;
    int        NExclamation;
    char    **Exclamation;
    int        NType;
    TYPE    *Type;
}POET;

typedef struct{
    int        N;
    NOUN     *Noun;
    NOUN    *Quality;
    char    *String;
    int        Genda;
    int        HisGenda;
    int        NTypes;
    int        *Types;
}THING;

typedef struct{
    void    *Next;
    void    *Data;
    size_t    Amount;
}MEMBLOCK;

//**************************************
//    Prototypes
//**************************************
POET    *LoadPoet(char *name);
void    ErrorExit(char *message);
void    ComposePoem(char *output, POET *poet, int seed);
int        RND(int range);
void    SetGenda(THING *t);
void    NewThing(POET *p, THING *t);
void    ChooseQuality(POET *p, THING *t);
void    Replace(char *key, char *replacement, char *str);
int        FindLine(char **lines, int nlines, char *str);
void    *GetMem(size_t amount, char *ErrorMessage);
char    *CloneString(char *from);
void    FreeMem(void *data);
void    ReadNoun(char *from, NOUN *noun, POET *p);
void    IndentLine(char *line);
int        StringToBin(char *str);
void    ShowHelp(void);
#define    FAIL(message)    {printf(message); goto fail;}

//**************************************
//    Static data
//**************************************
char    *He[]={"he","she","it","they","i","we"};
char    *Him[]={"him","her","it","them","me","us"};
char    *His[]={"his","her","its","their","my","our"};
char    *Himself[]={"himself","herself","itself","themselves","myself","ourselves"};

//    Constants
int            NumberLines=6,PrintWidth=60;
char        *SubStr,*ObjStr;
MEMBLOCK    *MemList=0;
size_t        TotalMemory=0;

int main(int argc, char *argv[])
{
    POET    *poet;
    int        j;
    char    input;
    char    *poem,*ss;
    int        seed;
    time_t    t;

    if(argc>1){
        if(!strcmp("?",argv[1]))ShowHelp();
    }
    if(argc==1)
        poet=LoadPoet("poet.txt");
    else
        poet=LoadPoet(argv[1]);

    //    Allocate space for strings
    SubStr=(char *)GetMem(MAX_LINE_LENGTH*sizeof(char), "Couldnt allocate space for subject string\n");
    ObjStr=(char *)GetMem(MAX_LINE_LENGTH*sizeof(char), "Couldnt allocate space for object string\n");

    //    Randomize timer
    time(&t);
    j=(int)t;
    srand(j);

    //    GET OPTIONS
    for(j=2; j<argc; j++){
        ss=argv[j];
        if( (ss[0]=='-') || (ss[0]='/') ){
            switch(ss[1]){
            case 'L': case 'l':
                NumberLines=StringToBin(&ss[2]);
                break;
            case 'W': case 'w':
                PrintWidth=StringToBin(&ss[2]);
                break;
            case 'S': case 's':
                seed=StringToBin(&ss[2]);
                srand(seed);
                break;
            case '?': case 'H': case 'h':
                ShowHelp();
                break;
            default:
                break;
            }
        }else if(ss[0]=='?'){
            ShowHelp();
        }
    }

    if(!poet)ErrorExit("Couldnt load poet data\n");
    poem=(char *)GetMem(64000,"Ran out of memory allocating buffer to recieve poems\n");
    seed=0;
    do{
        ComposePoem(poem, poet, seed);
        printf("\n\n");
        printf(poem);
        printf("\nENTER TO CONTINUE - Q = QUIT\n");
        input=getchar();
        seed++;
    }while( (input!='q') && (input!='Q') );

    ErrorExit(0);
    return 1;
}

//***********************************************
//    Show programs help screen
//***********************************************
//    Input:        None
//    Output:        None
//***********************************************
void    ShowHelp(void)
{
    printf(    "Random Poetry Generator Copyright 1997 - Paul Gaze\n"
            "Version 1.00   "__DATE__"\n"
            "\n"
            "Syntax: poem <filename> options\n"
            "\n"
            "Options can any of the following:\n"
            "    -Wnn  Set Characters per line to nn (default 60)\n"
            "    -Snn  Set random number seed to nn. Normaly its set\n"
            "          according to the current time\n"
            "    -Lnn  Set lines per poem to nn (default 6)\n"
            "    ?     Show this help screen\n"
            "\n"
            "filename is the name of the file containing the poetry data.\n"
            "If it isnt specified then the program will attempt to load\n"
            "a file called poet.txt\n"
            "\n"
    );
    ErrorExit("");
}

//***********************************************
//    Figure out the person of a noun, taking into
//    account if its quality is being used. Also
//    make list of types.
//***********************************************
//    Input:        Thing
//    Output:        None
//***********************************************
void    SetGenda(THING *t)
{
    t->HisGenda=t->Noun->Genda;
    if(t->Quality){
        t->Genda=t->Quality->Genda;
        t->Types=t->Quality->Types;
        t->NTypes=t->Quality->NTypes;
    }else{
        t->Genda=t->Noun->Genda;
        t->Types=t->Noun->Types;
        t->NTypes=t->Noun->NTypes;
    }
}

//***********************************************
//    Randomly choose a noun
//***********************************************
//    Input:        Poet data & output for noun
//    Output:        None
//***********************************************
void    NewThing(POET *p, THING *t)
{
    t->N=RND(p->NNoun);
    t->Noun=&p->Noun[t->N];
    t->Quality=0;
    SetGenda(t);
}

//***********************************************
//    Randomly choose a quality of a noun
//***********************************************
//    Input:        Poet data & thing to choose a
//                quality of
//    Output:        None
//***********************************************
void    ChooseQuality(POET *p, THING *t)
{
    int        j;
    TYPE    *type;

    if(!t->Noun->NTypes){
        ErrorExit("Strangely this noun had no types\n");
        return;
    }
    j=RND(t->Noun->NTypes);
    type=&p->Type[t->Noun->Types[j]];
    if(!type->NQuality){
        return;
    }
    j=RND(type->NQuality);
    t->Quality=&type->Quality[j];
    SetGenda(t);
}
//***********************************************
//    Substitute string
//***********************************************
//    Input:        String to replace, replacement,
//                string to work on
//    Output:        None
//***********************************************
void    Replace(char *key, char *replacement, char *str)
{
    char    *from, *comp, *to;
    int        j, nchar, move;

    for(; *str; str++){
        from=str;
        for(comp=key; *comp; comp++,from++){
            if(*comp!=*from)break;
        }
        if(*comp)continue;

        //    MAKE SPACE TO PUT IN SUBSTITUTE
        move=strlen(replacement)-strlen(key);
        if(move>0){
            from=str+strlen(str);
            to=from+move;
            nchar=strlen(str)-strlen(key)+1;
            for(j=nchar; j; j--){
                *to=*from;
                to--; from--;
            }
        }else if(move<0){
            from=str+strlen(replacement);
            to=from+move;
            while(*from){
                *to++=*from++;
            }
            *to++=0;
        }
        memcpy(str, replacement, strlen(replacement) );
    }
}




//***********************************************
//    Create a random poem
//***********************************************
//    Input:        output for string, poet data &
//                seed form random number generator
//    Output:        None
//***********************************************
void    ComposePoem(char *output, POET *poet, int seed)
{
    int        verb,UseableVerbs,i,j,k,xx;
    char    *ex,letter;
    VERB    *v;
    THING    sub,obj,temp;
    THING    sub_last,obj_last;

    sub.String=SubStr;
    obj.String=ObjStr;
    NewThing(poet, &sub);
    NewThing(poet, &obj);
    sub_last.N=-1;
    sub_last.Quality=0;
    obj_last.N=-1;
    obj_last.Quality=0;

    *output=0;
    for(j=0; j<NumberLines; j++){
        do{
            v=poet->Verb;
            UseableVerbs=0;
            for(k=0; k<poet->NVerb; k++,v++){

//***********************************************************
#define    CHECK_VERB                                            \
                for(i=0; i<sub.NTypes; i++){                \
                    if(sub.Types[i]==v->Subject)break;        \
                }                                            \
                if(i==sub.NTypes)continue;                    \
                for(i=0; i<obj.NTypes; i++){                \
                    if(obj.Types[i]==v->Object)break;        \
                }                                            \
                if(i==obj.NTypes)continue;
//***********************************************************
                CHECK_VERB
                UseableVerbs++;
            }
            if(!UseableVerbs){
                NewThing(poet, &sub);
                NewThing(poet, &obj);
            }
        }while(!UseableVerbs);
        verb=RND(UseableVerbs)+1;
        v=poet->Verb;
        for(v=poet->Verb; 1; v++){
            CHECK_VERB
            verb--;
            if(!verb)break;
        }
        if(RND(100)<33){
            ex=poet->Exclamation[RND(poet->NExclamation)];
        }else{
            ex=0;
        }


        //    GET OBJECT STRING
        if(obj.N==obj_last.N && obj.Quality==obj_last.Quality){
            sprintf( obj.String, Him[obj.Genda]);
        }else{
            if(obj.Quality){
                sprintf(obj.String, "%s %s",His[obj.HisGenda],obj.Quality->String);
            }else{
                sprintf(obj.String, obj.Noun->String);
            }
        }

        //    GET SUBJECT STRING
        if(sub.N==sub_last.N && sub.Quality==sub_last.Quality){
            sprintf( sub.String, He[sub.Genda]);
        }else{
            if(sub.Quality){
                sprintf(sub.String, "%s %s",His[sub.HisGenda],sub.Quality->String);
            }else{
                sprintf(sub.String, sub.Noun->String);
            }
        }
        if(ex){
            sprintf(output,"%s %s,\n", ex, v->String);
        }else{
            sprintf(output,"%s,\n", v->String);
        }
        Replace("*sub", sub.String, output);
        Replace("*psub", His[sub.Genda], output);
        Replace("*ref", Himself[sub.Genda], output);

        Replace("*obj", obj.String, output);
        Replace("*pobj", His[obj.Genda], output);

        //    MAKE FIRST LETTER CAPITAL
        letter=*output;
        if( (letter>='a') && (letter<='z') )letter+=('A'-'a');
        *output=letter;
        IndentLine(output);


        output+=(strlen(output));

        sub_last=sub;
        obj_last=obj;

        //    CHANGE OBJECT & SUBJECT
        xx=RND(100);
        if(xx<15){
            NewThing(poet, &obj);
        }else if(xx<30){
            NewThing(poet, &sub);
        }else if(xx<45){
            ChooseQuality(poet, &obj);
        }else if(xx<60){
            ChooseQuality(poet, &sub);
        }else if(xx<80){
            temp=sub;
            sub=obj;
            obj=temp;
        }
    }
    output-=2;
    *output='.';
}

//***********************************************
//    Return number in range 0 -> limit-1
//***********************************************
//    Input:        Range
//    Output:        Random number
//***********************************************
int    RND(int range)
{
    return    rand()%range;
}

//***********************************************
//    Format line to fit in display width
//***********************************************
//    Input:        String for line
//    Output:        None
//***********************************************
void    IndentLine(char *line)
{
    char    *indent="\n    ";
    char    *from,*to;
    int        move,nchar,j;

    while(1){
        nchar=strlen(line);
        if(nchar<PrintWidth)break;
        j=PrintWidth;
        while( line[j]!=' ' ){
            j--;
            if(j<0)return;
        }
        line=&line[j];
        move=strlen(indent)-1;
        nchar=strlen(line)+1-1;
        from=&line[strlen(line)];
        to=&from[move];
        while(nchar){
            *to=*from;
            to--; from--;
            nchar--;
        }
        memcpy(line, indent, strlen(indent));
        line++;
    }
}
//***********************************************
//    Exit code with an error message
//***********************************************
//    Input:        Pointer to error message
//    Output:        None
//***********************************************
void    ErrorExit(char *message)
{
    if(message)printf(message);

    //    Free all memory
    while(MemList){
        FreeMem(MemList->Data);
    }
    #if    DEBUG_MESSAGES
        printf("%d bytes left unfreed\n",(int)TotalMemory);
    #endif
    exit(1);
}
//***********************************************
//    Load data for poet from file
//***********************************************
//    Input:    File name
//    Output:    Pointer to poet data
//***********************************************
POET    *LoadPoet(char *name)
{
    char         *data=NULL,*from,*from2,*to,letter,*str,*str2;
    FILE        *f=NULL;
    size_t        length;
    int            nline, blank, j, k, doneit, n, start, end, nletter;
    int            iverb, sub_type, obj_type, finished;
    POET        *p=0;
    char        **line,*ss;
    NOUN        *noun;
    VERB        *v;
    TYPE_DATA    *TypeData=0, *t;
    TYPE        *tt;

    //    SET UP INITIAL STRUCTURE
    p=(POET *)GetMem(sizeof(POET),"Couldnt allocate space for poet data\n");
    memset(p, 0, sizeof(POET));

    //    LOAD IN DATA
    f=fopen(name,"rb");
    if(f==NULL)FAIL("Unable to open poet file\n");
    if(fseek(f, 0, SEEK_END))FAIL("Trouble reading poet file\n");
    length=ftell(f);
    data=(char *)GetMem(length+1, "Trouble allocating data to read poet file\n");
    if(fseek(f, 0, SEEK_SET))FAIL("Trouble reading poet file\n");;
    if(length!=fread(data, 1, length, f))FAIL("Trouble reading poet file\n");
    data[length]=0;
    fclose(f);

    //    REMOVE ESCAPE CHARACTERS
    from=to=data;
    while( (letter=*from++) ){
        if(letter!=0x0d)
            *to++=letter;
    }
    *to++=0;

    //    REMOVE COMMENTS & BLANK LINES
    from=to=data;
    while(1){
        letter=*from;
        if(!letter)break;
        if(letter==';'){
            while(1){
                letter=*from++;
                if( (letter=='\n') || (!letter) )break;
            }
        }else{
            blank=1;
            nline=0;
            from2=from;
            while(1){
                nline++;
                letter=*from2++;
                if( (letter=='\n') || (!letter) )break;
                if( (letter!=' ') && (letter!='    ') ){
                    blank=0;
                }
            }
            if(!blank){
                memcpy(to, from, nline);
                to+=nline;
            }
            from+=nline;
        }
    }
    *to++=0;

    //    DIVIDE INTO LINES
    nline=0;
    from=data;
    do{
        letter=*from++;
        if( (!letter) || (letter=='\n') ){
            nline++;
        }
    }while(letter);
    line=(char **)GetMem(nline*sizeof(char *), "Trouble allocating memory for poet file\n");
    from=data;
    for(j=0; j<nline; j++){
        line[j]=from;
        do{
            letter=*from++;
            if( (letter=='\n')||(!letter) )
                break;
        }while(1);
        from--;
        *from++=0;
    }

    //    GET RID OF GARBAGE AT END OF LINE
    for(j=0; j<nline; j++){
        from=line[j];
        n=strlen(from);
        doneit=0;
        for(;n>=0;n--){
            letter=from[n];
            switch(letter){
            case 0: case '    ':case ' ':
                from[n]=0;
                break;
            default:
                doneit=1;
                break;
            }
            if(doneit)break;
        }
    }

    //////////////////////////////////////
    //                                    //
    //    GET TYPES                        //
    //                                    //
    //////////////////////////////////////
    p->NType=0;
    for(j=0; j<nline; j++){
        str=line[j];
        str=strstr(str,"/");
        if(!str)continue;
        do{
            str2=strstr(str+1,"/");
            if(!str2)break;
            nletter=((int)str2)-((int)str)+1;
            for(t=TypeData; t; t=(TYPE_DATA *)t->Next){
                if(nletter!=strlen(t->String))continue;
                if( !memcmp(str,t->String,nletter) )break;
            }
            if(!t){
                p->NType++;
                t=(TYPE_DATA *)GetMem(sizeof(TYPE_DATA), 0);
                t->Next=TypeData;
                TypeData=t;
                t->String=(char *)GetMem(nletter+1, 0);
                memcpy(t->String, str, nletter);
                t->String[nletter]=0;
            }
            str=str2;
        }while(1);
    }
    p->Type=(TYPE *)GetMem(p->NType*sizeof(TYPE), 0);
    memset(p->Type, 0, p->NType*sizeof(TYPE));
    t=TypeData;
    for(j=0; j<p->NType; j++){
        p->Type[j].String=t->String;
        t=(TYPE_DATA *)t->Next;
    }

    //////////////////////////////////////
    //                                    //
    //    READ EXCLAMATIONS                //
    //                                    //
    //////////////////////////////////////
    start=FindLine(line, nline, "&EXCLAMATIONS");
    if(start==nline)FAIL("Couldnt find &EXCLAMATIONS\n");

    end=FindLine(line, nline, "&ENDEXCLAMATIONS");
    if(end==nline)FAIL("Couldnt find &ENDEXCLAMATIONS\n");
    p->NExclamation=end-start-1;
    if(p->NExclamation<=0)FAIL("Dodgy exclamation data\n");

    p->Exclamation=(char **)GetMem(p->NExclamation*sizeof(char *), "Trouble allocating memory for exclamation data\n");
    for(j=0; j<p->NExclamation; j++){
        from=line[start+j+1];
        p->Exclamation[j]=(char *)GetMem(strlen(from) + 1, "Couldnt allocate memory for exclamation data\n");
        strcpy(p->Exclamation[j], from);
    }

    //////////////////////////////////////
    //                                    //
    //    GET NOUNS                        //
    //                                    //
    //////////////////////////////////////
    start=FindLine(line, nline, "&NOUNS");
    if(start==nline)FAIL("Couldnt find &NOUNS\n");
    end=FindLine(line, nline, "&ENDNOUNS");
    if(end==nline)FAIL("Couldnt find &ENDNOUNS\n");
    p->NNoun=end-start-1;
    if(p->NNoun<=0)FAIL("No nouns found\n");

    noun=p->Noun=(NOUN *)GetMem(p->NNoun*sizeof(NOUN), "Ran out of memory\n");
    for(j=0; j<p->NNoun; j++, noun++){
        from=line[start+j+1];
        ReadNoun(from, noun, p);

    }

    //////////////////////////////////////
    //                                    //
    //    GET VERBS                        //
    //                                    //
    //////////////////////////////////////
    start=FindLine(line, nline, "&VERBS");
    if(start==nline)FAIL("Couldnt find &VERBS\n");
    end=FindLine(line, nline, "&ENDVERBS");
    if(end==nline)FAIL("Couldnt find &ENDVERBS\n");

    //    COUNT VERBS & ALLOCATE SPACE FOR THEM
    p->NVerb=0;
    for(j=start+1; j<end; j++){
        if(!strstr(line[j],"/")){
            p->NVerb++;
        }
    }
    if(!p->NVerb)FAIL("There arent any verbs\n");
    v=p->Verb=(VERB *)GetMem(p->NVerb*sizeof(VERB), "Ran out of space allocating memory for verbs\n");
    j=start+1;
    iverb=0;
    finished=0;
    while(!finished){
        if(!strstr(line[j],"/"))FAIL("corrupt verb data 1\n");
        sub_type=obj_type=-1;
        for(k=0; k<p->NType; k++){
            str=strstr(line[j],p->Type[k].String);
            if(!str)continue;
            if(str==line[j])sub_type=k;
            ss=line[j]+1;
            str=strstr(line[j],p->Type[k].String);
            if(str)obj_type=k;
        }
        if( (sub_type==-1)||(obj_type==-1) ){
            if(sub_type!=-1)printf("Subject = %s\n",p->Type[sub_type].String);
            if(obj_type!=-1)printf("Object = %s\n",p->Type[obj_type].String);
            FAIL("Corrupt verb data 2\n");
        }
        j++;
        while(!strstr(line[j],"/")){
            v->String=CloneString(line[j]);
            v->Subject=sub_type;
            v->Object=obj_type;
            v++;
            iverb++;
            if(iverb==p->NVerb){
                finished=1;
                break;
            }
            j++;
        }
    }
    //    MAKE SURE ALL VERBS HAVE SUBJECT & OBJECT
    v=p->Verb;
    for(j=0; j<p->NVerb; j++,v++){
        k=0;
        if(!strstr(v->String,"*sub"))k+=5;
        if(!strstr(v->String,"*obj"))k+=5;
        if(k){
            to=(char *)GetMem(strlen(v->String)+k+1,"Low memory\n");
            *to=0;
            if(!strstr(v->String,"*sub"))
                strcat(to,"*sub ");
            strcat(to, v->String);
            if(!strstr(v->String,"*obj"))
                strcat(to," *obj");
            FreeMem(v->String);
            v->String=to;
        }
    }

    //////////////////////////////////////
    //                                    //
    //    GET QUALITIES                    //
    //                                    //
    //////////////////////////////////////
    start=FindLine(line, nline, "&QUALITIES");
    if(start==nline)FAIL("Couldnt find &QUALITIES\n");
    end=FindLine(line, nline, "&ENDQUALITIES");
    if(end==nline)FAIL("Couldnt find &ENDQUALITIES\n");
    j=start+1;
    while(j<end){
        if( strstr(line[j],"(") )FAIL("Corrupt quality data\n");
        for(k=0; k<p->NType; k++){
            if(!strcmp(p->Type[k].String,line[j]))break;
        }
        if(k==p->NType)FAIL("Failed to find type\n");
        tt=&p->Type[k];

        //    COUNT NUMBER OF QUALITIES
        tt->NQuality=0;
        k=j+1;
        while(strstr(line[k],"(")){
            tt->NQuality++;
            k++;
            if(k==end)break;
        }
        noun=tt->Quality=(NOUN *)GetMem(tt->NQuality*sizeof(NOUN), 0);
        for(k=0; k<tt->NQuality; k++){
            ReadNoun(line[k+j+1], noun, p);
            noun++;
        }
        j+=(tt->NQuality+1);
    }

    return p;
fail:
    ErrorExit("Couldnt load poet\n");
    return 0;
}

//***********************************************
//    Make a copy of a string
//***********************************************
//    Input:        String to copy
//    Output:        Copy of string
//***********************************************
char    *CloneString(char *from)
{
    char *to;

    to=(char *)GetMem(strlen(from)+1, 0);
    strcpy(to, from);
    return to;
}


//***********************************************
//    Find line equal to given string
//***********************************************
//    Input:        list of lines, number of lines &
//                string to be searched for.
//    Output:        number of line on which string is
//                to be found or nlines if it isnt
//                found.
//***********************************************
int    FindLine(char **lines, int nlines, char *str)
{
    int    j;

    for(j=0; j<nlines; j++){
        if(!strcmp(str, lines[j]))break;
    }
    return j;
}

//***********************************************
//    Allocate memory
//***********************************************
//    Input:        Amount to allocate & message to
//                print if allocation fails
//    Output:        pointer to memory allocated
//***********************************************
void    *GetMem(size_t amount, char *ErrorMessage)
{
    void         *data=NULL;
    MEMBLOCK    *mb=NULL;

    data=malloc(amount);
    if(data==NULL)goto fail;
    mb=(MEMBLOCK *)malloc(sizeof(MEMBLOCK));
    if(mb==NULL)goto fail;
    mb->Data=data;
    mb->Amount=amount;
    mb->Next=MemList;
    MemList=mb;
    TotalMemory+=amount;
    return data;
fail:
    if(data!=NULL)free(data);
    if(mb!=NULL)free(mb);
    if(ErrorMessage)printf(ErrorMessage);
    printf("Couldnt allocate %d bytes\n",(int)amount);
    ErrorExit("Ran out of memory\n");
}

//***********************************************
//    Free memory
//***********************************************
//    Input:        Pointer to memory to free
//    Output:        None
//***********************************************
void    FreeMem(void *data)
{
    MEMBLOCK    *m,*last;

    m=MemList;
    if(m->Data==data){
        MemList=(MEMBLOCK *)m->Next;
    }else{
        last=m;
        m=(MEMBLOCK *)m->Next;
        while(m){
            if(m->Data==data)break;
            last=m;
            m=(MEMBLOCK *)m->Next;
        }
        if(!m)ErrorExit("Tried to free non existant memory block\n");
        last->Next=m->Next;
    }
    TotalMemory-=m->Amount;
    free(m->Data);
    free(m);
}

//***********************************************
//    Read data for noun out of string
//***********************************************
//    Input:        Data, output for noun & poet data
//    Output:        None
//***********************************************
void    ReadNoun(char *from, NOUN *noun, POET *p)
{
    char    *str;
    int        nletter, n, k;

    //    GET GENDA
    if( strstr(from,"(he)") ){
        noun->Genda=GENDA_HE;
    }else if( strstr(from,"(she)") ){
        noun->Genda=GENDA_SHE;
    }else if( strstr(from,"(it)") ){
        noun->Genda=GENDA_IT;
    }else if( strstr(from,"(they)") ){
        noun->Genda=GENDA_THEY;
    }else if( strstr(from,"(i)") ){
        noun->Genda=GENDA_I;
    }else if( strstr(from,"(we)") ){
        noun->Genda=GENDA_WE;
    }else{
        printf("Trouble on line:\n%s\n",from);
        FAIL("Couldnt find genda of noun\n");
    }

    //    GET STRING
    str=from;
    nletter=0;
    while(*str){
        if(*str=='(')break;
        str++;
        nletter++;
    }
    if(!*str)FAIL("Couldnt get noun string\n");
    noun->String=(char *)GetMem(nletter+1, 0);
    noun->String[nletter]=0;
    memcpy(noun->String, from, nletter);

    //    COUNT TYPES & ALLOCATE SPACE FOR THEM
    str=from;
    noun->NTypes=0;
    while(*str){
        if(*str=='/')noun->NTypes++;
        str++;
    }
    noun->NTypes--;
    if(!noun->NTypes)FAIL("No types found for verb\b");
    noun->Types=(int *)GetMem(noun->NTypes*sizeof(int), 0);

    //    SET TYPES ARRAY
    str=from;
    k=0;
    for(n=0; n<p->NType; n++){
        if(strstr(from, p->Type[n].String)){
            if(k==noun->NTypes)FAIL("Something went wrong\n");
            noun->Types[k]=n;
            k++;
        }
    }

    for(n=0; n<noun->NTypes; n++){
        k=noun->Types[n];
    }
    return;
fail:
    ErrorExit("It went wrong\n");
}

//***********************************************
//    Convert ASCII string to integer value
//***********************************************
//    Input:        String
//    Output:        Value
//***********************************************
int    StringToBin(char *str)
{
    int    sum=0,letter;

    while( (letter=*str++) ){
        letter-='0';
        if( (letter<0)||(letter>9) )break;
        sum=(sum*10)+letter;
    }
    return sum;
}